home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Magazine / Morphos / GCC / lib / gcc-lib / ppc-amigaos / 2.95.1 / sys-include / powerup / ppcpragmas / rexxsyslib_pragmas.h < prev    next >
C/C++ Source or Header  |  2000-03-13  |  6KB  |  215 lines
  1. /* Automatically generated header! Do not edit! */
  2.  
  3. #ifndef _PPCPRAGMA_REXXSYSLIB_H
  4. #define _PPCPRAGMA_REXXSYSLIB_H
  5. #ifdef __GNUC__
  6. #ifndef _PPCINLINE__REXXSYSLIB_H
  7. #include <powerup/ppcinline/rexxsyslib.h>
  8. #endif
  9. #else
  10.  
  11. #ifndef POWERUP_PPCLIB_INTERFACE_H
  12. #include <powerup/ppclib/interface.h>
  13. #endif
  14.  
  15. #ifndef POWERUP_GCCLIB_PROTOS_H
  16. #include <powerup/gcclib/powerup_protos.h>
  17. #endif
  18.  
  19. #ifndef NO_PPCINLINE_STDARG
  20. #define NO_PPCINLINE_STDARG
  21. #endif/* SAS C PPC inlines */
  22.  
  23. #ifndef REXXSYSLIB_BASE_NAME
  24. #define REXXSYSLIB_BASE_NAME RexxSysBase
  25. #endif /* !REXXSYSLIB_BASE_NAME */
  26.  
  27. #define    ClearRexxMsg(msgptr, count)    _ClearRexxMsg(REXXSYSLIB_BASE_NAME, msgptr, count)
  28.  
  29. static __inline void
  30. _ClearRexxMsg(void *RexxSysBase, struct RexxMsg *msgptr, unsigned long count)
  31. {
  32. struct Caos    MyCaos;
  33.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  34. //    MyCaos.M68kStart    =    NULL;
  35. //    MyCaos.M68kSize        =    0;
  36.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  37. //    MyCaos.PPCStart        =    NULL;
  38. //    MyCaos.PPCSize        =    0;
  39.     MyCaos.a0        =(ULONG) msgptr;
  40.     MyCaos.d0        =(ULONG) count;
  41.     MyCaos.caos_Un.Offset    =    (-156);
  42.     MyCaos.a6        =(ULONG) RexxSysBase;    
  43.     PPCCallOS(&MyCaos);
  44. }
  45.  
  46. #define    CreateArgstring(string, length)    _CreateArgstring(REXXSYSLIB_BASE_NAME, string, length)
  47.  
  48. static __inline UBYTE *
  49. _CreateArgstring(void *RexxSysBase, UBYTE *string, unsigned long length)
  50. {
  51. struct Caos    MyCaos;
  52.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  53. //    MyCaos.M68kStart    =    NULL;
  54. //    MyCaos.M68kSize        =    0;
  55.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  56. //    MyCaos.PPCStart        =    NULL;
  57. //    MyCaos.PPCSize        =    0;
  58.     MyCaos.a0        =(ULONG) string;
  59.     MyCaos.d0        =(ULONG) length;
  60.     MyCaos.caos_Un.Offset    =    (-126);
  61.     MyCaos.a6        =(ULONG) RexxSysBase;    
  62.     return((UBYTE *)PPCCallOS(&MyCaos));
  63. }
  64.  
  65. #define    CreateRexxMsg(port, extension, host)    _CreateRexxMsg(REXXSYSLIB_BASE_NAME, port, extension, host)
  66.  
  67. static __inline struct RexxMsg *
  68. _CreateRexxMsg(void *RexxSysBase, struct MsgPort *port, UBYTE *extension, UBYTE *host)
  69. {
  70. struct Caos    MyCaos;
  71.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  72. //    MyCaos.M68kStart    =    NULL;
  73. //    MyCaos.M68kSize        =    0;
  74.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  75. //    MyCaos.PPCStart        =    NULL;
  76. //    MyCaos.PPCSize        =    0;
  77.     MyCaos.a0        =(ULONG) port;
  78.     MyCaos.a1        =(ULONG) extension;
  79.     MyCaos.d0        =(ULONG) host;
  80.     MyCaos.caos_Un.Offset    =    (-144);
  81.     MyCaos.a6        =(ULONG) RexxSysBase;    
  82.     return((struct RexxMsg *)PPCCallOS(&MyCaos));
  83. }
  84.  
  85. #define    DeleteArgstring(argstring)    _DeleteArgstring(REXXSYSLIB_BASE_NAME, argstring)
  86.  
  87. static __inline void
  88. _DeleteArgstring(void *RexxSysBase, UBYTE *argstring)
  89. {
  90. struct Caos    MyCaos;
  91.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  92. //    MyCaos.M68kStart    =    NULL;
  93. //    MyCaos.M68kSize        =    0;
  94.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  95. //    MyCaos.PPCStart        =    NULL;
  96. //    MyCaos.PPCSize        =    0;
  97.     MyCaos.a0        =(ULONG) argstring;
  98.     MyCaos.caos_Un.Offset    =    (-132);
  99.     MyCaos.a6        =(ULONG) RexxSysBase;    
  100.     PPCCallOS(&MyCaos);
  101. }
  102.  
  103. #define    DeleteRexxMsg(packet)    _DeleteRexxMsg(REXXSYSLIB_BASE_NAME, packet)
  104.  
  105. static __inline void
  106. _DeleteRexxMsg(void *RexxSysBase, struct RexxMsg *packet)
  107. {
  108. struct Caos    MyCaos;
  109.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  110. //    MyCaos.M68kStart    =    NULL;
  111. //    MyCaos.M68kSize        =    0;
  112.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  113. //    MyCaos.PPCStart        =    NULL;
  114. //    MyCaos.PPCSize        =    0;
  115.     MyCaos.a0        =(ULONG) packet;
  116.     MyCaos.caos_Un.Offset    =    (-150);
  117.     MyCaos.a6        =(ULONG) RexxSysBase;    
  118.     PPCCallOS(&MyCaos);
  119. }
  120.  
  121. #define    FillRexxMsg(msgptr, count, mask)    _FillRexxMsg(REXXSYSLIB_BASE_NAME, msgptr, count, mask)
  122.  
  123. static __inline BOOL
  124. _FillRexxMsg(void *RexxSysBase, struct RexxMsg *msgptr, unsigned long count, unsigned long mask)
  125. {
  126. struct Caos    MyCaos;
  127.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  128. //    MyCaos.M68kStart    =    NULL;
  129. //    MyCaos.M68kSize        =    0;
  130.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  131. //    MyCaos.PPCStart        =    NULL;
  132. //    MyCaos.PPCSize        =    0;
  133.     MyCaos.a0        =(ULONG) msgptr;
  134.     MyCaos.d0        =(ULONG) count;
  135.     MyCaos.d1        =(ULONG) mask;
  136.     MyCaos.caos_Un.Offset    =    (-162);
  137.     MyCaos.a6        =(ULONG) RexxSysBase;    
  138.     return((BOOL)PPCCallOS(&MyCaos));
  139. }
  140.  
  141. #define    IsRexxMsg(msgptr)    _IsRexxMsg(REXXSYSLIB_BASE_NAME, msgptr)
  142.  
  143. static __inline BOOL
  144. _IsRexxMsg(void *RexxSysBase, struct RexxMsg *msgptr)
  145. {
  146. struct Caos    MyCaos;
  147.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  148. //    MyCaos.M68kStart    =    NULL;
  149. //    MyCaos.M68kSize        =    0;
  150.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  151. //    MyCaos.PPCStart        =    NULL;
  152. //    MyCaos.PPCSize        =    0;
  153.     MyCaos.a0        =(ULONG) msgptr;
  154.     MyCaos.caos_Un.Offset    =    (-168);
  155.     MyCaos.a6        =(ULONG) RexxSysBase;    
  156.     return((BOOL)PPCCallOS(&MyCaos));
  157. }
  158.  
  159. #define    LengthArgstring(argstring)    _LengthArgstring(REXXSYSLIB_BASE_NAME, argstring)
  160.  
  161. static __inline ULONG
  162. _LengthArgstring(void *RexxSysBase, UBYTE *argstring)
  163. {
  164. struct Caos    MyCaos;
  165.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  166. //    MyCaos.M68kStart    =    NULL;
  167. //    MyCaos.M68kSize        =    0;
  168.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  169. //    MyCaos.PPCStart        =    NULL;
  170. //    MyCaos.PPCSize        =    0;
  171.     MyCaos.a0        =(ULONG) argstring;
  172.     MyCaos.caos_Un.Offset    =    (-138);
  173.     MyCaos.a6        =(ULONG) RexxSysBase;    
  174.     return((ULONG)PPCCallOS(&MyCaos));
  175. }
  176.  
  177. #define    LockRexxBase(resource)    _LockRexxBase(REXXSYSLIB_BASE_NAME, resource)
  178.  
  179. static __inline void
  180. _LockRexxBase(void *RexxSysBase, unsigned long resource)
  181. {
  182. struct Caos    MyCaos;
  183.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  184. //    MyCaos.M68kStart    =    NULL;
  185. //    MyCaos.M68kSize        =    0;
  186.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  187. //    MyCaos.PPCStart        =    NULL;
  188. //    MyCaos.PPCSize        =    0;
  189.     MyCaos.d0        =(ULONG) resource;
  190.     MyCaos.caos_Un.Offset    =    (-450);
  191.     MyCaos.a6        =(ULONG) RexxSysBase;    
  192.     PPCCallOS(&MyCaos);
  193. }
  194.  
  195. #define    UnlockRexxBase(resource)    _UnlockRexxBase(REXXSYSLIB_BASE_NAME, resource)
  196.  
  197. static __inline void
  198. _UnlockRexxBase(void *RexxSysBase, unsigned long resource)
  199. {
  200. struct Caos    MyCaos;
  201.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  202. //    MyCaos.M68kStart    =    NULL;
  203. //    MyCaos.M68kSize        =    0;
  204.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  205. //    MyCaos.PPCStart        =    NULL;
  206. //    MyCaos.PPCSize        =    0;
  207.     MyCaos.d0        =(ULONG) resource;
  208.     MyCaos.caos_Un.Offset    =    (-456);
  209.     MyCaos.a6        =(ULONG) RexxSysBase;    
  210.     PPCCallOS(&MyCaos);
  211. }
  212.  
  213. #endif /* SASC Pragmas */
  214. #endif /* !_PPCPRAGMA_REXXSYSLIB_H */
  215.